import 'dart:async';
import 'dart:isolate';

void main() async {
  print('主线程开始执行');

  // 1. 基本 Future 使用
  basicFutureExample();

  // 2. async/await 语法
  await asyncAwaitExample();

  // 3. Stream 使用
  streamExample();

  // 4. Isolate 使用（在单独线程执行计算密集型任务）
  await isolateExample();

  print('主线程执行完毕');
}

// 1. 基本 Future 使用示例
void basicFutureExample() {
  print('\n== 基本 Future 示例 ==');

  // 创建一个 Future
  Future<String> fetchData() {
    return Future.delayed(Duration(seconds: 1), () => '数据加载完成');
  }

  // 处理 Future 结果
  fetchData().then((data) {
    print('Future 结果: $data');
  }).catchError((error) {
    print('Future 错误: $error');
  }).whenComplete(() {
    print('Future 处理完成');
  });
}

// 2. async/await 语法示例
Future<void> asyncAwaitExample() async {
  print('\n== async/await 示例 ==');

  try {
    // 使用 await 等待 Future 完成
    String result = await fetchDataAsync();
    print('async/await 结果: $result');
  } catch (error) {
    print('async/await 错误: $error');
  }
}

Future<String> fetchDataAsync() {
  return Future.delayed(Duration(seconds: 1), () {
    // 模拟错误情况
    // throw Exception('数据加载失败');
    return 'async/await 数据加载完成';
  });
}

// 3. Stream 使用示例
void streamExample() {
  print('\n== Stream 示例 ==');

  // 创建一个 Stream
  Stream<int> countStream(int to) async* {
    for (int i = 1; i <= to; i++) {
      await Future.delayed(Duration(seconds: 1));
      yield i; // 使用 yield 生成值
    }
  }

  // 监听 Stream
  StreamSubscription<int> subscription = countStream(3).listen(
    (value) {
      print('Stream 值: $value');
    },
    onError: (error) {
      print('Stream 错误: $error');
    },
    onDone: () {
      print('Stream 完成');
    },
  );

  // 可以在需要时暂停、恢复或取消订阅
  // subscription.pause();
  // subscription.resume();
  // subscription.cancel();
}

// 4. Isolate 使用示例
Future<void> isolateExample() async {
  print('\n== Isolate 示例 ==');

  // 创建接收端口以获取 Isolate 的消息
  ReceivePort receivePort = ReceivePort();

  // 启动新的 Isolate
  Isolate isolate = await Isolate.spawn(
    calculateFactorial, // Isolate 入口函数
    receivePort.sendPort, // 发送端口，用于向主 Isolate 发送消息
  );

  // 监听来自 Isolate 的消息
  receivePort.listen((message) {
    if (message is SendPort) {
      // 从子 Isolate 收到发送端口，现在可以向它发送消息
      message.send(10); // 计算 10 的阶乘
    } else {
      print('Isolate 计算结果: $message');
      // 计算完成后关闭接收端口并终止 Isolate
      receivePort.close();
      isolate.kill(priority: Isolate.immediate);
    }
  });
}

// Isolate 入口函数（必须是顶级函数或静态方法）
void calculateFactorial(SendPort sendPort) {
  // 创建接收端口以接收主 Isolate 的消息
  ReceivePort port = ReceivePort();
  sendPort.send(port.sendPort); // 向主 Isolate 发送此 Isolate 的发送端口

  // 监听主 Isolate 发送的消息
  port.listen((message) {
    if (message is int) {
      int result = 1;
      for (int i = 1; i <= message; i++) {
        result *= i;
      }
      sendPort.send('$message 的阶乘是: $result');
    }
  });
}  
